/**
 * 模拟ElasticSearch服务
 *
 * 在实际项目中，这应该是通过API与服务器端的ElasticSearch实例通信
 * 这里为了演示，使用前端模拟数据
 */

// 模拟数据集
const mockDocuments = [
  {
    _id: 'just-pure-redux',
    _source: {
      title: 'Redux 与 Next.js | JustPure',
      content: 'Redux是React生态系统中广泛使用的状态管理库，而Next.js是一个流行的React框架，它提供了服务器端渲染、静态站点生成和其他优化功能。将两者结合使用可能会遇到一些挑战，本文将探讨一些最佳实践。Next.js的服务器端渲染特性要求我们处理Redux状态的同步问题。在服务器端，我们需要确保在渲染页面之前已经准备好初始状态。next-redux-wrapper会处理服务器端和客户端之间的状态同步，确保两端渲染出相同的内容。',
      excerpt: '如何在Next.js中使用Redux进行状态管理的最佳实践',
      tags: ['Redux', 'Next.js', 'React', '状态管理'],
      date: '2025-03-10'
    },
    _score: 5.8
  },
  {
    _id: 'ariadocs-quicklook',
    _source: {
      title: 'AriaDocs 快速上手指南',
      content: 'AriaDocs是一个现代化的文档生成工具，它专为开发者设计，可以帮助你创建美观、交互式的API文档和技术文档。本文将带你快速了解AriaDocs的主要功能和使用方法。AriaDocs使用Markdown格式编写文档，支持多种扩展语法。AriaDocs可以自动从TypeScript类型定义或JSDoc注释生成API文档。AriaDocs提供了一个完整的文档解决方案，帮助你创建专业、易用的技术文档。',
      excerpt: 'AriaDocs是一个现代化的文档生成工具，本文将介绍其基本用法',
      tags: ['AriaDocs', '文档', '工具'],
      date: '2025-03-05'
    },
    _score: 4.3
  },
  {
    _id: 'grtblog-deploy',
    _source: {
      title: '如何部署你的 Grtblog 网站',
      content: 'Grtblog是一个为开发者设计的博客框架，它基于Next.js构建，提供了丰富的功能和优雅的设计。本文将详细介绍如何将你的Grtblog网站部署到各种平台。Vercel是部署Next.js应用的最佳平台之一，也是Grtblog推荐的部署方式。Netlify也是一个很好的静态网站托管平台，支持Grtblog的所有功能。如果你有自己的服务器，也可以将Grtblog部署到那里。',
      excerpt: '从零开始，手把手教你如何部署Grtblog到各种平台',
      tags: ['Grtblog', '教程', '部署'],
      date: '2025-02-28'
    },
    _score: 3.9
  },
  {
    _id: 'hyperos2-experience',
    _source: {
      title: 'MIUI到HyperOS2的使用体验',
      content: '从MIUI 14升级到HyperOS2的体验分享，包括界面变化、性能提升和新功能介绍。HyperOS2是小米新一代操作系统，相比MIUI有了很大的改进。HyperOS2的动画更加流畅，界面设计更加简洁，多任务处理能力也有提升。文章详细介绍了新系统的主要变化和使用心得。',
      excerpt: '从MIUI 14升级到HyperOS2的体验分享，包括界面变化、性能提升和新功能介绍',
      tags: ['HyperOS', 'MIUI', '体验'],
      date: '2025-02-20'
    },
    _score: 2.5
  },
  {
    _id: 'pf4j-spring-plugins',
    _source: {
      title: '使用pf4j-spring创建插件化API系统',
      content: '本文介绍如何使用pf4j-spring框架构建一个灵活的插件化API系统，实现业务逻辑的动态加载和热插拔。pf4j是一个强大的Java插件框架，而pf4j-spring则是其与Spring框架的集成。通过插件化架构，可以实现系统功能的灵活扩展，而不需要修改核心代码。文章详细讲解了插件开发、加载、生命周期管理的实现方式。',
      excerpt: '本文介绍如何使用pf4j-spring框架构建一个灵活的插件化API系统',
      tags: ['Java', 'Spring', 'pf4j', '插件系统'],
      date: '2025-02-15'
    },
    _score: 1.8
  },
  {
    _id: 'react-ecosystem-2025',
    _source: {
      title: '2025年React生态系统概览',
      content: '本文对2025年React生态系统进行全面概览，包括最新的库、工具和最佳实践。React在2025年继续保持其在前端框架中的领先地位，有了许多新的改进和工具。文章讨论了React的最新特性，以及周边生态系统的发展，包括状态管理、路由、表单处理等方面的最佳选择。',
      excerpt: '本文对2025年React生态系统进行全面概览，包括最新的库、工具和最佳实践',
      tags: ['React', '前端', '生态系统'],
      date: '2025-01-15'
    },
    _score: 4.2
  }
];

/**
 * 模拟ElasticSearch查询
 * @param {string} searchTerm - 搜索词
 * @param {object} options - 搜索选项
 * @returns {Promise} 搜索结果
 */
export const searchContent = async (searchTerm, options = {}) => {
  // 默认选项
  const defaultOptions = {
    fields: ['title', 'content', 'tags'],
    fuzziness: 'AUTO',
    highlight: true,
    from: 0,
    size: 10
  };

  // 合并选项
  const searchOptions = { ...defaultOptions, ...options };

  // 模拟网络延迟
  await new Promise(resolve => setTimeout(resolve, 300));

  // 执行搜索
  let results = [...mockDocuments];

  // 如果有搜索词，进行过滤
  if (searchTerm) {
    const lowerSearchTerm = searchTerm.toLowerCase();

    // 使用权重进行搜索
    results = results.filter(doc => {
      // 创建匹配得分
      let score = 0;
      let matches = [];

      // 搜索标题
      if (searchOptions.fields.includes('title') || searchOptions.fields.includes('title^2')) {
        const titleMatches = doc._source.title.toLowerCase().includes(lowerSearchTerm);
        if (titleMatches) {
          score += 3; // 标题匹配权重高
          matches.push('title');
        }
      }

      // 搜索内容
      if (searchOptions.fields.includes('content')) {
        const contentMatches = doc._source.content.toLowerCase().includes(lowerSearchTerm);
        if (contentMatches) {
          score += 1; // 内容匹配权重低
          matches.push('content');
        }
      }

      // 搜索标签
      if (searchOptions.fields.includes('tags') || searchOptions.fields.includes('tags^3')) {
        const tagMatches = doc._source.tags.some(tag =>
          tag.toLowerCase().includes(lowerSearchTerm)
        );
        if (tagMatches) {
          score += 2; // 标签匹配权重中
          matches.push('tags');
        }
      }

      // 模拟模糊匹配 (如果开启)
      if (searchOptions.fuzziness && (score === 0)) {
        // 简单的模拟模糊匹配 - 如果搜索词长度 > 4 且字符有70%匹配
        if (lowerSearchTerm.length > 4) {
          const titleWords = doc._source.title.toLowerCase().split(' ');
          const contentWords = doc._source.content.toLowerCase().split(' ');
          const allWords = [...titleWords, ...contentWords];

          for (const word of allWords) {
            if (word.length > 4) {
              let matchCount = 0;
              for (let i = 0; i < Math.min(lowerSearchTerm.length, word.length); i++) {
                if (lowerSearchTerm[i] === word[i]) {
                  matchCount++;
                }
              }

              const matchPercentage = matchCount / lowerSearchTerm.length;
              if (matchPercentage > 0.7) {
                score += 0.5; // 模糊匹配权重最低
                matches.push('fuzzy');
                break;
              }
            }
          }
        }
      }

      // 更新文档得分
      if (score > 0) {
        doc._score = score;

        // 添加高亮 (如果开启)
        if (searchOptions.highlight) {
          doc.highlight = {};

          // 高亮标题
          if (matches.includes('title')) {
            const titleRegex = new RegExp(`(${lowerSearchTerm})`, 'gi');
            doc.highlight.title = [
              doc._source.title.replace(titleRegex, '<em>$1</em>')
            ];
          }

          // 高亮内容
          if (matches.includes('content')) {
            // 找出匹配位置的上下文
            const contentLower = doc._source.content.toLowerCase();
            const matchIndex = contentLower.indexOf(lowerSearchTerm);

            if (matchIndex !== -1) {
              // 提取包含匹配词的上下文 (前后30个字符)
              const startPos = Math.max(0, matchIndex - 30);
              const endPos = Math.min(doc._source.content.length, matchIndex + lowerSearchTerm.length + 30);
              let contextSnippet = doc._source.content.substring(startPos, endPos);

              // 高亮匹配词
              const snippetRegex = new RegExp(`(${lowerSearchTerm})`, 'gi');
              contextSnippet = contextSnippet.replace(snippetRegex, '<em>$1</em>');

              doc.highlight.content = [contextSnippet];
            }
          }
        }

        return true;
      }

      return false;
    });
  }

  // 按得分排序
  results.sort((a, b) => b._score - a._score);

  // 分页
  results = results.slice(searchOptions.from, searchOptions.from + searchOptions.size);

  // 构造返回结果
  return {
    took: Math.floor(Math.random() * 50) + 5, // 模拟查询耗时 (5-55ms)
    timed_out: false,
    hits: {
      total: {
        value: results.length,
        relation: "eq"
      },
      max_score: results.length > 0 ? Math.max(...results.map(doc => doc._score)) : 0,
      hits: results
    }
  };
};

// 导出更多ElasticSearch功能
export const getIndexStatus = async () => {
  // 模拟获取索引状态
  await new Promise(resolve => setTimeout(resolve, 200));

  return {
    status: 'green',
    documentCount: mockDocuments.length,
    indices: ['blog', 'pages', 'users'],
    clusterHealth: 'optimal'
  };
};

export const getPopularSearchTerms = async () => {
  // 模拟获取热门搜索词
  await new Promise(resolve => setTimeout(resolve, 150));

  return [
    { term: 'React', count: 128 },
    { term: 'Next.js', count: 87 },
    { term: 'Grtblog', count: 63 },
    { term: 'Redux', count: 51 },
    { term: 'JavaScript', count: 42 }
  ];
};
